import java.util.Arrays;

public class TestDemo {
    public static void main(String[] args) {
        int[] array = {11,12,31,14,45,16};
        int ret = maxNum(array);
        System.out.println(ret);
    }
    public static int maxNum(int[] array) {
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(array[i] > max) {
                max = array[i];
            }
        }
        return max;
    }
    //copyOf是对数组进行了深拷贝
    //浅拷贝：
    //浅拷贝：
    //拷贝之后的数组 通过array2[0]是否影响array1[0]的值， 能就是深拷贝，不能就是浅拷贝
    //数组中的数据都是基本数据类型。
    //所以要达到深拷贝，一定要记住对象也是需要拷贝的！！！！
    //
    //拷贝的对象是什么对象
    //假设你拷贝对象只是单纯拷贝吗？
    //对于 对象来说，如果代码本身自己实现了深拷贝的代码，没有实现深拷贝的代码，只是简单的拷贝。浅拷贝
    //拷贝的是什么对象：1.基本数据类型  深拷贝
    //2.引用类型 （1）只是单纯的使用这几个方法 （2）使用了这几个方法.并且代码也处理了深拷贝，那么就是深拷贝了。
    public static void main13(String[] args) {
        int[] array = {1,2,3,4,5,6};
        int[] array1 = array;//这不是拷贝
    }
    /**
     * 第四种拷贝方式。 对象的clone()方法
     * @param args
     */
    public static void main12(String[] args) {
        int[] array = {1,2,3,4,5,6};
        int[] ret = array.clone();//产生了一个副本对象
        System.out.println(Arrays.toString(ret));
    }
    /**
     * 第三种拷贝方式，
     * System.arraycopy
     *     public static native void arraycopy(Object src,  int  srcPos,
     *                                         Object dest, int destPos,
     *                                         int length);
     * @param args
     */
    public static void main11(String[] args) {
        int[] array ={1,2,3,4,5,6};
        int[] copy = new int[array.length];
        System.arraycopy(array,0,copy,0,array.length);//native 本地的 这个方法是有c/c++实现的2、速度是很快的3、运行是在本地方法栈上的
        System.out.println(Arrays.toString(copy));
    }
    public static void main10(String[] args) {
        int[] array = {1,2,3,4,5,6};
        int[] ret = Arrays.copyOfRange(array,1,3);
        System.out.println(Arrays.toString(ret));//[1-3)不能取到3左闭右开，
        //java中from ..to..都是左闭右开的
    }
    /**
     * Array.copyOf 整体拷贝也能扩容
     * @param args
     */
    public static void main9(String[] args) {
        int[] array = {1,2,3,4,5,6};
        int[] ret = Arrays.copyOf(array,2 * array.length);
        System.out.println(Arrays.toString(ret));
    }
    /**
     * for循环实现拷贝
     * @param args
     */
    public static void main8(String[] args) {
        int[] array = {1,2,3,4,5,6};
        int[] ret = copyArray(array);
        System.out.println(Arrays.toString(ret));
/*        int[] newarray = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            newarray[i] = array[i];
        }
        System.out.println(Arrays.toString(newarray));*/
    }
    public static int[] copyArray(int[] array) {
        int[] newArray = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            newArray[i] = array[i];
        }
        return newArray;
    }
    public static void main7(String[] args) {
        int[] array = {1,2,3,4,5,6};
        String ret = myToString(array);
        System.out.println(ret);
    }
    public static String myToString(int[] array) {
        if (array == null) {
            return null;
        }
        if (array.length == 0) {
            return "";
        }
        String ret = "[";
        int i = 0;
        for (i = 0; i < array.length - 1; i++) {
            ret = ret + array[i] +", ";
        }
        ret = ret +array[i] +"]";
        return ret;
    }
    //数组作为方法的返回值
    public static void main6(String[] args) {
        int[] array = {1,2,3,4,5,6};
        /*int[] ret =*/
        System.out.println("执行之前的array数组" + Arrays.toString(array));
        //func1(array);
//fun3 对象如果要被回收，那么一定没有被其他的引用
        int [] ret = func3(array);
        System.out.println("执行之后的array数组" +Arrays.toString(array));
        System.out.println(Arrays.toString(ret));
    }
    //通过array2改变了原来对象的值
    public static void func1(int[] array2) {
        for (int i = 0; i < array2.length; i++) {
            array2[i] *=2;
        }
    }
    public static int[] func3(int[] array) {
        int[] ret = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            ret[i] = array[i] * 2;
        }
        return ret;
    }
    //引用类型： String 数组 类 接口 枚举 抽象类
    public static void main5(String[] args) {
        int[] array1 = {1,2,3,4,5,6};
        int[] array2 = array1;
        //是不是代表array2这个引用指向array1这个引用？？？
        // 不是，而是array2这个引用指向了arrqy1这个引用指向的对象（引用不能指向引用）
        int[] array3 = null;//代表这个引用不指向任何对象
        //java上不能拿到栈上的地址，只能拿到堆上的地址。
//        System.out.println(array3.length);//NullPointerException 空指针异常
        //通过null访问属性的时候就会报空指针异常
        System.out.println(array3[0]);//也是空指针异常
        //引用类型如果你不知道他将来要指向哪个对象，那么初始化为null
    }
    public static void main4(String[] args) {
        int a = 10;
        int b = 20;
        int[] array = {a,b};
        System.out.println("交换前："+array[0] +" " + array[1] +" ");
        swap(array);
        System.out.println("交换后："+array[0] +" " + array[1] +" ");
        System.out.println(a);
        System.out.println(b);
    }
    public static void swap(int[] array) {
        int tmp = array[0];
        array[0] = array[1];
        array[1] = tmp;
    }
    public static void show(int[] array) {
        /*for(int x : array) {
            System.out.println(x);*/
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i] +" ");
        }
    }
    public static void main3(String[] args) {
        int[] array1 = {1,2,3,4,5,6};
        show(array1);
        //1 2 3 4 5 6
        func(array1);
        show(array1);
        //99 2 3 4 5 6
    }
    public static void func(int[] array) {
        array[0] = 99;
    }
    //jvm:是一个软件  c/c++代码写的
    //jvm
    public static void main2(String[] args) {
        /*int[] array = new int[10];//默认元素是0
        System.out.println(Arrays.toString(array));*/
    }
    //数组是一块连续的内存，它存放的是同一类型数据的集合
    //数组是引用类型
    //先用起来
    //数组名.length得到数组的长度
    //数组越界：ArrayIndexOutOfBoundsException
    public static void main1(String[] args) {
             //引用变量 引用 当前这个变量里存储的是一个地址  ------局部变量  //栈 存在栈里
        //对象就是一个实体 对象存在堆上 array是一个引用 指向一个对象 引用了一个对象
        //array1是一个变量 也是一个引用
        //引用是一个变量存放的是对象的地址
        int[] array = {1,2,3,4,5,6};
        int[] array1 = new int[10];
        int[] array3 = new int[]{1,2,3,4,5,6,7};
        System.out.println("数组的长度：" +array.length);
        //3种打印方式
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
       /* System.out.println("测试越界：");
        System.out.println(array[6]);//ArrayIndexOutOfBoundsException - 数组越界异常*/
        //增强for循环  --- for-each循环 for(数组每个元素：数组名称)  只能遍历数组
        for(int x:array) {
            System.out.println(x);
        }
        //将当前的数组转换为字符串的形式进行输出
        System.out.println(Arrays.toString(array));
        //把Arrays工具包测试一遍
        //Arrays :工具-》帮助我们操作数电的工具
     }

}

